package com.avic.rong.utils;

import android.text.TextUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Creater: Created by wangyz on 2017/2/8.
 * Email: 936804097@qq.com
 */

public class StringUtils {

    private StringUtils() {
        throw new UnsupportedOperationException("u can't instantiate me...");
    }

    /**
     * 判断字符串是否为null或长度为0
     *
     * @param s 待校验字符串
     * @return {@code true}: 空<br> {@code false}: 不为空
     */
    public static boolean isEmpty(CharSequence s) {
        return s == null || s.length() == 0;
    }

    /**
     * 判断字符串是否为null或全为空格
     *
     * @param s 待校验字符串
     * @return {@code true}: null或全空格<br> {@code false}: 不为null且不全空格
     */
    public static boolean isSpace(String s) {
        return (s == null || s.trim().length() == 0);
    }

    /**
     * 判断两字符串是否相等
     *
     * @param a 待校验字符串a
     * @param b 待校验字符串b
     * @return {@code true}: 相等<br>{@code false}: 不相等
     */
    public static boolean equals(CharSequence a, CharSequence b) {
        if (a == b) return true;
        int length;
        if (a != null && b != null && (length = a.length()) == b.length()) {
            if (a instanceof String && b instanceof String) {
                return a.equals(b);
            } else {
                for (int i = 0; i < length; i++) {
                    if (a.charAt(i) != b.charAt(i)) return false;
                }
                return true;
            }
        }
        return false;
    }

    /**
     * 判断两字符串忽略大小写是否相等
     *
     * @param a 待校验字符串a
     * @param b 待校验字符串b
     * @return {@code true}: 相等<br>{@code false}: 不相等
     */
    public static boolean equalsIgnoreCase(String a, String b) {
        return (a == b) || (b != null) && (a.length() == b.length()) && a.regionMatches(true, 0, b, 0, b.length());
    }

    /**
     * null转为长度为0的字符串
     *
     * @param s 待转字符串
     * @return s为null转为长度为0字符串，否则不改变
     */
    public static String null2Length0(String s) {
        return s == null ? "" : s;
    }

    /**
     * 返回字符串长度
     *
     * @param s 字符串
     * @return null返回0，其他返回自身长度
     */
    public static int length(CharSequence s) {
        return s == null ? 0 : s.length();
    }

    /**
     * 首字母大写
     *
     * @param s 待转字符串
     * @return 首字母大写字符串
     */
    public static String upperFirstLetter(String s) {
        if (isEmpty(s) || !Character.isLowerCase(s.charAt(0))) return s;
        return String.valueOf((char) (s.charAt(0) - 32)) + s.substring(1);
    }

    /**
     * 首字母小写
     *
     * @param s 待转字符串
     * @return 首字母小写字符串
     */
    public static String lowerFirstLetter(String s) {
        if (isEmpty(s) || !Character.isUpperCase(s.charAt(0))) return s;
        return String.valueOf((char) (s.charAt(0) + 32)) + s.substring(1);
    }

    /**
     * 反转字符串
     *
     * @param s 待反转字符串
     * @return 反转字符串
     */
    public static String reverse(String s) {
        int len = length(s);
        if (len <= 1) return s;
        int mid = len >> 1;
        char[] chars = s.toCharArray();
        char c;
        for (int i = 0; i < mid; ++i) {
            c = chars[i];
            chars[i] = chars[len - i - 1];
            chars[len - i - 1] = c;
        }
        return new String(chars);
    }

    /**
     * 转化为半角字符
     *
     * @param s 待转字符串
     * @return 半角字符串
     */
    public static String toDBC(String s) {
        if (isEmpty(s)) return s;
        char[] chars = s.toCharArray();
        for (int i = 0, len = chars.length; i < len; i++) {
            if (chars[i] == 12288) {
                chars[i] = ' ';
            } else if (65281 <= chars[i] && chars[i] <= 65374) {
                chars[i] = (char) (chars[i] - 65248);
            } else {
                chars[i] = chars[i];
            }
        }
        return new String(chars);
    }

    /**
     * 转化为全角字符
     *
     * @param s 待转字符串
     * @return 全角字符串
     */
    public static String toSBC(String s) {
        if (isEmpty(s)) return s;
        char[] chars = s.toCharArray();
        for (int i = 0, len = chars.length; i < len; i++) {
            if (chars[i] == ' ') {
                chars[i] = (char) 12288;
            } else if (33 <= chars[i] && chars[i] <= 126) {
                chars[i] = (char) (chars[i] + 65248);
            } else {
                chars[i] = chars[i];
            }
        }
        return new String(chars);
    }


    public static String zanChange(int zanNum) {

        if (zanNum > 100) {
            return "100+";
        } else if (zanNum > 1000) {
            return "1000+";
        } else if (zanNum > 10000) {
            return "10000+";
        } else {
            return String.valueOf(zanNum);
        }
    }



    public static String getCutString(String temp) {
        if (temp.length() >= temp.indexOf(".") + 2) {
            return temp.substring(0, temp.indexOf(".") + 2);
        } else {
            return temp;
        }
    }


    public static List<String> getGrade(String qualityIndex) {
        List<String> gradeList = new ArrayList<>();

        if (Float.valueOf(qualityIndex) >= 9.0) {
            gradeList.clear();
            gradeList.add("五星");
            gradeList.add("#1fc232");
        } else if (Float.valueOf(qualityIndex) < 9.0 && Float.valueOf(qualityIndex) >= 8.0) {
            gradeList.clear();
            gradeList.add("四星半");
            gradeList.add("#eec200");
        } else if (Float.valueOf(qualityIndex) < 8.0 && Float.valueOf(qualityIndex) >= 7.0) {
            gradeList.clear();
            gradeList.add("四星");
            gradeList.add("#fb8400");
        } else if (Float.valueOf(qualityIndex) < 7.0 && Float.valueOf(qualityIndex) >= 6.0) {
            gradeList.clear();
            gradeList.add("三星半");
            gradeList.add("#fe0a00");
        } else {
            gradeList.clear();
            gradeList.add("三星");
            gradeList.add("#fe0a00");
        }
        return gradeList;
    }

    public static String getGradeColorByIndex(String qualityIndex) {
        if (Float.valueOf(qualityIndex) >= 9.0) {
            return "<font color='#1fc232'>" + qualityIndex + "</font>";
        } else if (Float.valueOf(qualityIndex) < 9.0 && Float.valueOf(qualityIndex) >= 8.0) {
            return "<font color='#eec200'>" + qualityIndex + "</font>";
        } else if (Float.valueOf(qualityIndex) < 8.0 && Float.valueOf(qualityIndex) >= 7.0) {
            return "<font color='#fb8400'>" + qualityIndex + "</font>";
        } else if (Float.valueOf(qualityIndex) < 7.0 && Float.valueOf(qualityIndex) >= 6.0) {
            return "<font color='#fe0a00'>" + qualityIndex + "</font>";
        } else {
            return "<font color='#fe0a00'>" + qualityIndex + "</font>";
        }
    }


    public static String numberChange(long count) {
        if (count > 10000) {
            return "10000+";
        } else if (count > 1000) {
            return "1000+";
        } else if (count > 100) {
            return "100+";
        } else {
            return String.valueOf(count);
        }

    }

    public static String redWord(String keyword) {
        return "<font color='#ff3430'>" + keyword + "</font>";
    }

    public static String redPriceWord(String keyword) {
        return "<font color='#ff5959'>" + keyword + "</font>";
    }


    public static String getParamByUrl(String url, String name) {
        url += "&";
        String pattern = "(\\?|&){1}#{0,1}" + name + "=[a-zA-Z0-9]*(&{1})";
        Pattern r = Pattern.compile(pattern);
        Matcher m = r.matcher(url);
        if (m.find()) {
            System.out.println(m.group(0));
            return m.group(0).split("=")[1].replace("&", "");
        } else {
            return null;
        }
    }


    public static String dealString(String value) {
        if (TextUtils.isEmpty(value)) {
            return "";
        } else if (value.equals("null")) {
            return "";
        } else if (value.equals("(null)")) {
            return "";
        } else if (value.equals("<null>")) {
            return "";
        } else {
            return value;
        }

    }
}